System and method for processing a data structure

ABSTRACT

A system and a method for processing a data structure includes the steps of: providing an incomplete data structure arranged to represent source information; processing the incomplete data structure to determine at least one estimated data element of an output data structure; and transforming the source information to output information associated with the output data structure based on a combination of the incomplete data structure and the at least one estimated data element.

TECHNICAL FIELD

The present invention relates to a system and method for processing a data structure, and particularly, although not exclusively, to a system and method for matrix completion.

BACKGROUND

Data and signals may be in electronic form and may be transmitted electrically. During transmission, electronic signals may be degraded with introduced noise due to various reasons, which may further result in incomplete transmission with missing and/or noisy data at the receiving end.

In some occasion, data stored in electronic form may also encountered partial loss due to poor data management. Therefore, data processing for restoring or retrieving valuable information based on incomplete data structures may be important in various applications.

SUMMARY OF THE INVENTION

In accordance with a first aspect of the present invention, there is provided a method for processing a data structure, comprising the step of: providing an incomplete data structure arranged to represent source information; processing the incomplete data structure to determine at least one estimated data element of an output data structure; and transforming the source information to output information associated with the output data structure based on a combination of the incomplete data structure and the at least one estimated data element.

In an embodiment of the first aspect, the data structure is arranged to contain a plurality of data elements.

In an embodiment of the first aspect, the incomplete data structure contains at least one noisy data element.

In an embodiment of the first aspect, at least one of the plurality of data elements is missing in the incomplete data structure.

In an embodiment of the first aspect, the output data structure includes the at least one estimated data element filled in at least one corresponding missing entries in the incomplete data structure.

In an embodiment of the first aspect, the data structure includes a matrix filled with the plurality of data elements.

In an embodiment of the first aspect, the incomplete data structure is a low-rank matrix.

In an embodiment of the first aspect, the step of processing the incomplete data structure includes factorizing the low-rank matrix.

In an embodiment of the first aspect, the step of processing the incomplete data structure further comprises a step of

-norm minimization of residual with 0<p≤2.

In an embodiment of the first aspect, the step of processing the incomplete data structure further comprises a step of processing the factorized low-rank matrix by solving a (n₁+n₂) linear

-regression problem, wherein n₁ and n₂ denote a row number and a column number of the low-rank matrix.

In an embodiment of the first aspect, the process of solving a (n₁+n₂) linear

-regression problem involves an iterative process.

In an embodiment of the first aspect, the iterative process is an iteratively reweighted least squares process.

In an embodiment of the first aspect, the step of processing the incomplete data structure further comprising a step of applying an alternating direction method of multipliers in an

-space.

In an embodiment of the first aspect, the step of applying the alternating direction method of multipliers in an

-space includes solving a least squares (LS) matrix factorization problem in each of a plurality of iterations.

In an embodiment of the first aspect, the least squares matrix factorization problem is solved using a linear least squares regression process.

In an embodiment of the first aspect, the step of applying the alternating direction method of multipliers in an

-space includes obtaining a proximity operator of a p^(th) power of the

-norm.

In an embodiment of the first aspect, the proximity operator includes a closed-form solution for p=1.

In an embodiment of the first aspect, obtaining the proximity operator of a p^(th) power of the

-norm includes root finding of a scalar nonlinear equation for p<1.

In an embodiment of the first aspect, the source information is a source image including a missing portion.

In an embodiment of the first aspect, the output information is an inpainted image based on the source image.

In accordance with a second aspect of the present invention, there is provided a method for image processing, comprising the steps of: transforming a source image to a matrix representation including a data structure; processing the data structure with the method in accordance with the first aspect so as to modify the matrix representation including the output data structure; and transforming the modified matrix representation to an output image.

In an embodiment of the second aspect, the method further comprises the step of converting the source image to a gray-scale image, wherein the gray-scale image is represented by the matrix representation.

In accordance with a third aspect of the present invention, there is provided a system for use in processing a data structure, comprising: a transformation module arranged to generate an incomplete data structure representing source information; and a processing module arranged to process the incomplete data structure so as to determine at least one estimated data element of an output data structure; wherein the transformation module is further arranged to transform the source information to output information associated with the output data structure based on a combination of the incomplete data structure and the at least one estimated data element.

In an embodiment of the third aspect, the data structure is arranged to contain a plurality of data elements.

In an embodiment of the third aspect, the incomplete data structure contains at least one noisy data element.

In an embodiment of the third aspect, at least one of the plurality of data elements is missing in the incomplete data structure.

In an embodiment of the third aspect, the output data structure includes the at least one estimated data element filled in at least one corresponding missing entries in the incomplete data structure.

In an embodiment of the third aspect, the data structure includes a matrix filled with the plurality of data elements.

In an embodiment of the third aspect, the incomplete data structure is a low-rank matrix.

In an embodiment of the third aspect, the source information is a source image including a missing portion.

In an embodiment of the third aspect, the output information is an inpainted image based on the source image.

In an embodiment of the third aspect, the transformation module is further arranged to convert the source image to a gray-scale image, wherein the gray-scale image is represented by the incomplete data structure.

BRIEF DESCRIPTION OF THE DRAWINGS

Embodiments of the present invention will now be described, by way of example, with reference to the accompanying drawings in which:

FIG. 1 is a schematic diagram of a computing server for operation as a system for use in processing a data structure in accordance with one embodiment of the present invention;

FIG. 2 is a schematic diagram of an embodiment of the system for processing an image in accordance with one embodiment of the present invention, wherein a source image is processed and transformed to an inpainted image based on a matrix completion method;

FIG. 3 is a plot showing results of normalized root mean square error (RMSE) versus iteration number in noise-free case processed with the methods in accordance with embodiments of the present invention and other alternative methods;

FIG. 4 is a plot showing results of normalized RMSE versus iteration number in noisy case processed with the methods in accordance with embodiments of the present invention and other alternative methods;

FIG. 5 is a plot showing results of normalized RMSE versus signal-to-noise ratio (SNR) processed with the methods in accordance with embodiments of the present invention and other alternative methods; and

FIG. 6 is a set of source and output images showing results of image inpainting in salt-and-pepper noise processed with the methods in accordance with embodiments of the present invention and other alternative methods.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT

The inventors have, through their own research, trials and experiments, devised that matrix completion may refer to recovery of a low-rank matrix. The recovery process may be based on only a subset of possibly noisy entries of the initial matrix.

Preferably, matrix completion may involve finding missing entries of a low-rank matrix from incomplete and/or noisy observations. The inventors devised that many real-world signals may be approximated by matrices whose ranks are much smaller than their column and row lengths.

For example, matrix completion may be used to predict user preferences with the use of a database of over 100 million movie ratings made by 480,189 users in 17,770 films, which corresponds to the task of completing a matrix with around 99% missing entries. A report may be generated based on the actual preferences and the matrix completion results.

Preferably, matrix completion may be formulated as a constrained rank minimization problem, but it is generally NP-hard. Nevertheless, it can be relaxed via nuclear norm minimization and a typical solver is the singular value thresholding (SVT) method which requires full singular value decomposition (SVD). Assuming that the rank is known, matrix recovery can also be tackled via iterative hard thresholding approach including the singular value projection (SVP) method where only truncated SVD is needed.

In another example, matrix factorization may be applied. The unknown matrix may be modelled as a product of two much smaller matrices so that the low-rank property is automatically fulfilled. However, some of these matrix completion methods may not work well when the observations contain outliers because their derivation is based on the

₂-space or Gaussian noise assumption. In fact, the validity of the Gaussian distribution may be at best approximate in reality, however the occurrence of non-Gaussian impulsive noise may also exist. For example, the impulsive salt-and-pepper noise commonly arises in image processing and imaging.

With reference to FIG. 1, an embodiment of the present invention is illustrated. This embodiment is arranged to provide a system for use in processing a data structure, comprising: a transformation module arranged to generate an incomplete data structure representing source information; and a processing module arranged to process the incomplete data structure so as to determine at least one estimated data element of an output data structure; wherein the transformation module is further arranged to transform the source information to output information associated with the output data structure based on a combination of the incomplete data structure and the at least one estimated data element.

Preferably, in one example, the system may be used to process a source image including a missing portion. By using the matrix completion method in accordance with the embodiments of the present invention, the missing portion may be estimated based on the other portions and/or information of the source image, and therefore the source image may be recovered with the estimation.

In this embodiment, the transformation module and the processing module are implemented by or for operation on a computer having an appropriate user interface. The computer may be implemented by any computing architecture, including stand-alone PC, client/server architecture, “dumb” terminal/mainframe architecture, or any other appropriate architecture. The computing device is appropriately programmed to implement the invention.

Referring to FIG. 1, there is shown a schematic diagram of a computer or a computing server 100 which in this embodiment comprises a server 100 arranged to operate, at least in part if not entirely, the system for use in processing a data structure in accordance with one embodiment of the invention. The server 100 comprises suitable components necessary to receive, store and execute appropriate computer instructions. The components may include a processing unit 102, read-only memory (ROM) 104, random access memory (RAM) 106, and input/output devices such as disk drives 108, input devices 110 such as an Ethernet port, a USB port, etc. Display 112 such as a liquid crystal display, a light emitting display or any other suitable display and communications links 114. The server 100 includes instructions that may be included in ROM 104, RAM 106 or disk drives 108 and may be executed by the processing unit 102. There may be provided a plurality of communication links 114 which may variously connect to one or more computing devices such as a server, personal computers, terminals, wireless or handheld computing devices. At least one of a plurality of communications link may be connected to an external computing network through a telephone line or other type of communications link.

The server may include storage devices such as a disk drive 108 which may encompass solid state drives, hard disk drives, optical drives or magnetic tape drives. The server 100 may use a single disk drive or multiple disk drives. The server 100 may also have a suitable operating system 116 which resides on the disk drive or in the ROM of the server 100.

The system has a database 120 residing on a disk or other storage device which is arranged to store at least one record 122. The database 120 is in communication with the server 100 with an interface, which is implemented by computer software residing on the server 100.

Alternatively, the database 120 may also be implemented as a stand-alone database system in communication with the server 100 via an external computing network, or other types of communication links.

With reference to FIG. 2, there is shown an embodiment of the system for use in processing a data structure 200. In this embodiment, the system is used to process source information having a data structure. The data structure contains a plurality of data elements. If the data structure is incomplete, i.e. at least one of the plurality of data elements is missing in the incomplete data structure, the system may attempt to process and complete the data structure by determining at least one estimated data element of an output data structure.

Preferably, the system 200 may comprise a transformation module 202 arranged to generate an incomplete data structure representing a source information 206, and a processing module 204 arranged to process the incomplete data structure so as to determine at least one estimated data element of an output data structure. The transformation module 202 may then transform the source information 206 to output information 208 associated with the output data structure determined by the processing module 204.

Referring to FIG. 2, the source information is a source image 206 and the output information is an output inpainted image 208. The source image 206 includes one or more missing portion 206A. When the source image is represented by a data structure or transformed into a matrix representation including the data structure, the matrix and the data structure is incomplete with a plurality of entries corresponding to the missing image data. For example, the matrix representation may include a plurality of data element representing the image pixels of the source image 206.

As discussed earlier in this disclosure, matrix completion technology may be applied so as to fill the incomplete matrix with estimated data elements and thus completing the matrix, by combining the incomplete data structure and the estimated data element. Subsequently, the modified matrix may be transformed to form an output image 208. Hence, the source image 206 may be transformed to an inpainted image 208 as output information provided by the system 200.

In this example, the output data structure includes the at least one estimated data element filled in the corresponding missing entries in the incomplete data structure. The “blanks” 206A in the source image 206 is filled with image portions which are estimated based on the other parts of the source information 206.

Preferably, the incomplete data structure is a low-rank matrix, and the processing of the incomplete data structure preferably includes factorizing the low-rank matrix and

-norm minimization of residual with 0<p≤2. The process may include iteratively solving (n₁+n₂) linear

-regression problems, where n₁ and n₂ represent the numbers of row and column of the incomplete/target matrix, respectively. The process may also apply an alternating direction method of multipliers (ADMM) for low-rank matrix factorization employing the incomplete entries in the

-space.

Preferably, there is one user-defined parameter in the invention, namely, the target rank, which is not difficult to determine in practical applications.

The process may begin with letting M_(Ω)∈

^(n) ¹ ^(×n) ² be a matrix with missing entries where Ω is a subset of the complete set of entries [n₁]×[n₂], with [n] being the list {1, . . . , n}. The (i,j) entry of M_(Ω), denoted by m_(Ωi,j), can be written as:

$\begin{matrix} {m_{{\Omega \; i},j} = \left\{ {\begin{matrix} m_{i,j} & {{{if}\mspace{14mu} \left( {i,j} \right)} \in \Omega} \\ {0,} & {otherwise} \end{matrix}.} \right.} & (1) \end{matrix}$

{m_(i,j)} are the available observations. The task of matrix completion is to find X∈

^(n) ¹ ^(×n) ² given M_(Ω) by incorporating the low-rank information. Mathematically, it is formulated as a rank minimization problem:

$\begin{matrix} {{\min\limits_{X}\mspace{14mu} {{{rank}(X)}\mspace{14mu} {s.t.\mspace{14mu} X_{\Omega}}}} = {M_{\Omega}.}} & (2) \end{matrix}$

Preferably, among all matrices consistent with the observed entries, the solution is the one with the minimum rank. In the presence of additive zero-mean noise, (2) can be modified as:

$\begin{matrix} {{\min\limits_{X}\mspace{11mu} {{{rank}(X)}\mspace{14mu} {s.t.\mspace{14mu} {{X_{\Omega} - M_{\Omega}}}_{F}^{2}}}} \leq \epsilon_{F}} & (3) \end{matrix}$

where ∥⋅∥_(F) denotes the Frobenius norm of a matrix and ϵ_(F)>0 is a tolerance parameter that controls the fitting error. Unfortunately, the rank minimization problem of (2) or (3) is NP-hard. One standard approach is to replace the nonconvex rank by the convex nuclear norm where full/truncated SVD is required, which is computationally demanding particularly when n₁ or n₂ is large. Another popular direction which avoids performing SVD is to apply matrix factorization:

$\begin{matrix} {{\min\limits_{U,V}{f_{2}\left( {U,V} \right)}}:={{({UV})_{\Omega} - M_{\Omega}}}_{F}^{2}} & (4) \end{matrix}$

where U∈

^(n) ¹ ^(×r) and V∈

^(r×n) ² with r being the target rank which is a user-defined parameter. After solving U and V, the solution is obtained as X=UV. In an embodiment of the present invention, (4) may be generalized by replacing the Frobenius norm by the

-norm where 0<p≤0.2 to design an efficient matrix completion approach even when M_(Ω) contains outlier measurements:

$\begin{matrix} {{\min\limits_{U,V}{f_{p}\left( {U,V} \right)}}:={{({UV})_{\Omega} - M_{\Omega}}}_{p}^{p}} & (5) \end{matrix}$

where ∥⋅∥_(p) denotes the element-wise

-norm of a matrix defined as:

$\begin{matrix} {{X_{\Omega}}_{p} = {\left( {\sum\limits_{{({i,j})} \in \Omega}{x_{i,j}}^{p}} \right)^{1/p}.}} & (6) \end{matrix}$

Preferably, (5) may be solved by adopting the alternating minimization strategy:

$\begin{matrix} {{V^{k + 1} = {\arg \; {\min\limits_{V}{{\left( {U^{k}V} \right)_{\Omega} - M_{\Omega}}}_{p}^{p}}}}{and}} & (7) \\ {U^{k + 1} = {\arg \; {\min\limits_{U}{{\left( {UV}^{k + 1} \right)_{\Omega} - M_{\Omega}}}_{p}^{p}}}} & (8) \end{matrix}$

where the transformation is initialized with U⁰ and U^(k) represents the estimate of U at the kth iteration.

Subsequently, (7) may be solved for a fixed U:

$\begin{matrix} {{\min\limits_{V}{f_{p}(V)}}:={{({UV})_{\Omega} - M_{\Omega}}}_{p}^{p}} & (9) \end{matrix}$

where the superscript (⋅)^(k) is dropped for notational simplicity. By denoting the i th row of U and the j th column of V as u_(i) ^(T) and v_(j), respectively, where u_(i), v_(j)∈

^(r), i=1, . . . , n₁, j=1, . . . , n₂, (9) can be rewritten as

$\begin{matrix} {{\min\limits_{V}{f_{p}(V)}}:={\sum\limits_{{({i,j})} \in \Omega}{{{{u_{i}^{T}v_{j}} - m_{i,j}}}^{p}.}}} & (10) \end{matrix}$

Because f_(p)(V) is decoupled with respect to v_(j), (10) is equivalent to solving the following n₂ independent subproblems:

$\begin{matrix} {{{\min\limits_{v_{j}}{f_{p}\left( v_{j} \right)}}:={\sum\limits_{i \in \mathcal{I}_{j}}{{{u_{i}^{T}v_{j}} - m_{i,j}}}^{p}}},{j = 1},\ldots \mspace{14mu},n} & (11) \end{matrix}$

where

={j₁, . . . , j_(|I) _(j) _(|)}⊆{1, . . . , n₁} denotes the set containing the row indices for the jth column in Ω. Here |

_(j)| stands for the cardinality of

_(j) and in general |

_(j)|>r.

As an illustration,

_(j) is determined as follows. Consider M_(Ω)∈

^(4×3):

$\begin{matrix} {M_{\Omega} = \begin{bmatrix} 0 & \times & 0 \\  \times & 0 & \times \\ 0 & \times & \times \\  \times & 0 & \times  \end{bmatrix}} & (12) \end{matrix}$

where the observed and missing entries are denoted by x and 0, respectively. For j=1, the (2,1) and (4,1) entries are observed, thus

₁={2,4}. In addition,

₂={1,3} and

₃={2,3,4}. Apparently, Σ_(j=1) ^(n) ² |

_(j)|=|Ω|. Defining a matrix U

_(j) ∈

^(|)

^(j) ^(|×r) containing the |

_(j)| rows indexed by

_(j):

$\begin{matrix} {U_{\mathcal{I}_{j}} = \begin{bmatrix} u_{{j\;}_{1}}^{T} \\ \vdots \\ u_{j{\mathcal{I}_{j}}}^{T} \end{bmatrix}} & (13) \end{matrix}$

and a vector b

_(j) =[m_(j) ₁ _(,j), . . . ,

]^(T)∈

^(|)

^(j) ^(|), then (11) is compactly rewritten as

$\begin{matrix} {{\min\limits_{v_{j}}{f_{p}\left( v_{j} \right)}}:={{{U_{\mathcal{I}_{j}}v_{j}} - b_{\mathcal{I}_{j}}}}_{p}^{p}} & (14) \end{matrix}$

which is a robust linear regression in

-space. For p=2, (14) is a linear least squares (LS) problem with solution being v_(j)=U

_(j) ^(†)b

_(j) , and the corresponding computational complexity is

(|

_(j)|r²).

For 0<p<2, the (n₁+n₂) linear

-regression of (14) may be solved by an iterative process, such as the iteratively reweighted least squares (IRLS) process where global convergence can be achieved for the convex case of p≥2 while only a stationary point is obtained for the nonconvex case of p<1. At the tth iteration, the IRLS solves the following weighted LS problem:

$\begin{matrix} {v_{j}^{t + 1} = {\arg \; {\min\limits_{v_{j}}{{W^{t}\left( {{U_{\mathcal{I}_{j}}v_{j}} - b_{\mathcal{I}_{j}}} \right)}}_{2}^{2}}}} & (15) \end{matrix}$

where W^(L)=diag(w₁ ^(L), . . . , w_(n) ₁ ^(t)) is a diagonal weighting matrix with the ith diagonal element being

$\begin{matrix} {w_{i}^{t} = {\frac{1}{\left( {{e_{i}^{t}}^{2} + \epsilon} \right)^{\frac{1 - {p/2}}{2}}}.}} & (16) \end{matrix}$

The e_(i) ^(t) is the i th element of the residual vector e^(t)=

−

and ∈>0 is a small positive parameter to avoid division by zero and ensure numerical stability, especially for p≤1. In one example, a value of ∈ is taken as ∈=100∈_(machine) with ∈_(machine) being the machine precision. Only an LS problem is required to solve in each iteration of the IRLS. Therefore, the complexity of the

-regression in (14) is

(|

_(j)|r²N_(IRLS)) where N_(IRLS) is the iteration number required for the IRLS to converge. Since the IRLS has a fast convergence rate, N_(IRLS) will not be large, with a typical value of several tens, and is independent of the problem dimension. The total complexity for solving the n₂

-regressions of (10) is

(|Ω|r²N_(IRLS)) due to Σ_(j=1) ^(n) ² |

_(j)|=|Ω|.

Since (7) and (8) have the same structure, (8) may be solved in the same manner. The ith row of U is updated by

$\begin{matrix} {\min\limits_{u_{i}^{T}}{{{u_{i}^{T}V_{_{i}}} - b_{_{i}}^{T}}}_{p}^{p}} & (17) \end{matrix}$

where

_(i)={i₁, . . . ,

}⊆{1, . . . , n₂} is the set containing the column indices for the ith row in Ω. Using (12) again, only the (1,2) entry is observed for i=1, and thus

₁={2}. In addition,

₂={1,3},

₃={2,3}, and

₄={1,3}. Here,

∈

contains the |

_(i)| columns indexed by

_(i) and

b_(_(i)^(T) = [m_(i, i₁), …  , m_(i, i_(_(i)))]^(T) ∈ ℝ^(_(i))).

The complexity of solving (17) is

(|

_(i)|r²N_(IRLS)) and hence the total complexity for solving the n₁

-regressions is

(|Ω|r²N_(IRLS)) because Σ_(i=1) ^(n) ¹ |

_(i)|=|Ω|.

The iterative

-regression for matrix completion is summarized as the process below. The complexity for a k-iteration is

(|Ω|r²N_(IRLS)). For the special case at p=2, the process reduces to solving the problem of (4). In this case, N_(IRLS)=1 and the complexity reduces to

(|Ω|r²) per k-iteration. In some examples, the number of observed entries is much smaller than the number of total entries, that is, |Ω|<<n₁n₂. Thus, the process may become more computationally efficient as the percentage of the observations decreases.

Process 1: Input: M_(Ω), Ω, and rank r  Initialize: Randomly initialize U⁰ ϵ

 Determine {

}_(j=1) ^(n) ² and {

}_(i=1) ^(n) ¹ according to Ω.  for k = 0, 1, . . . do   // Fix U^(k), optimize V   for j = 1, 2, . . . , n₂ do     $\left. \upsilon_{j}^{k + 1}\leftarrow{\arg \mspace{14mu} {\min\limits_{\upsilon_{j}}{{{U_{I_{j}}^{k}\upsilon_{j}} - b_{I_{j}}}}_{p}^{p}}} \right.$   end for   // Fix V^(k+1), optimize U   for i = 1, 2, . . . , n₁ do     $\left. \left( u_{i}^{T} \right)^{k + 1}\leftarrow{\arg \mspace{14mu} {\min\limits_{u_{i}^{T}}{{{u_{i}^{T}V_{J_{4}}^{k + 1}} - b_{J_{i}}^{T}}}_{p}^{p}}} \right.$   end for   Stop if a termination condition is satisfied.  end for Output: X = U^(k+1)V^(k+1)

Advantageously, the total complexity of the iterative

-regression is

(|Ω|r²N_(IRLS)K_(reg)) where K_(reg) is the number of outer iterations, namely, the k-iteration. A value of several tens of K_(reg) is sufficient for convergence. In addition, the n₂ problems of (14) and n₁ problems of (17) are independent and hence can be solved using parallel computing. This may allow parallel/distributed realization, and therefore is suitable for big-data applications where the matrix sizes are very large.

In an alternative embodiment, the system 200 may perform the step of processing the incomplete data structure which further comprises a step of applying an alternating direction method of multipliers (ADMM) in an

p-space. At each iteration of the ADMM, it requires solving a LS matrix factorization problem and calculating the proximity operator of the pth power of the

-norm.

Preferably, the LS factorization may be efficiently solved using linear LS regression while the proximity operator has closed-form solution for p=1 or can be obtained by root finding of a scalar nonlinear equation for p<1.

The ADMM process begins with introducing Z_(Ω)=(UV)_(Ω)−M_(Ω), and (4) is equivalent to the linearly constrained problem:

$\begin{matrix} {{\min\limits_{U,V,Z_{\Omega}}{{Z_{\Omega}}_{p}^{p}\mspace{14mu} {s.t.\mspace{14mu} Z_{\Omega}}}} = {({UV})_{\Omega} - {M_{\Omega}.}}} & (18) \end{matrix}$

Note that z_(Ωi,j)=0 if (i,j)∉Ω. The augmented Lagrangian of (18) is:

$\begin{matrix} {{\mathcal{L}_{\rho}\left( {U,V,Z_{\Omega},\Lambda_{\Omega}} \right)} = {{Z_{\Omega}}_{p}^{p} + {\langle{\Lambda_{\Omega},{({UV})_{\Omega} - Z_{\Omega} - M_{\Omega}}}\rangle} + {\frac{\rho}{2}{{({UV})_{\Omega} - Z_{\Omega} - M_{\Omega}}}_{F}^{2}}}} & (19) \end{matrix}$

where Λ_(Ω)∈

with λ_(Ωi,j)=0 for (i,j)∉Ω contains |Ω| Lagrange multipliers (dual variables),

A,B

=Σ_(i,j)a_(i,j)b_(i,j) represents the inner product of A and B, and p>0 is the penalty parameter. The Lagrange multiplier method solves the constrained problem of (18) by finding a saddle point of the augmented Lagrangian:

$\begin{matrix} {\max\limits_{\Lambda_{\Omega}}{\min\limits_{U,V,Z_{\Omega}}{{\mathcal{L}_{\rho}\left( {U,V,Z_{\Omega},\Lambda_{\Omega}} \right)}.}}} & (20) \end{matrix}$

ADMM uses the following iteration steps:

$\begin{matrix} {\left( {U^{k + 1},V^{k + 1}} \right) = {\arg {\min\limits_{U,V}{\mathcal{L}_{\rho}\left( {U,V,Z_{\Omega}^{k},\Lambda_{\Omega}^{k}} \right)}}}} & (21) \\ {Z_{\Omega}^{k + 1} = {\arg {\min\limits_{Z_{\Omega}}{\mathcal{L}_{\rho}\left( {U^{k + 1},V^{k + 1},Z_{\Omega},\Lambda_{\Omega}^{k}} \right)}}}} & (22) \end{matrix}$

and

Λ_(Ω) ^(k+1)=Λ_(Ω) ^(k)+ρ(U ^(k+1) V ^(k+1))_(Ω) −Z _(Ω) ^(k+1) −M _(Ω))  (23)

to determine the saddle point in (20).

Since the gradient of

_(ρ)(U^(k+1),V^(k+1),Z_(Ω) ^(k+1),Λ_(Ω)) with respect to (w.r.t.) Λ_(Ω) is

$\begin{matrix} {\frac{\partial{\mathcal{L}_{\rho}\left( {U^{k + 1},V^{k + 1},Z_{\Omega}^{k + 1},\Lambda_{\Omega}} \right)}}{\partial\Lambda_{\Omega}} = {\left( {U^{k + 1}V^{k + 1}} \right)_{\Omega} - Z_{\Omega}^{k + 1} - M_{\Omega}}} & (24) \end{matrix}$

It is observed that (23) adopts a gradient ascent with a step size ρ to update the dual variable Λ_(Ω). ADMM updates (U,V) and Z_(Ω) in an alternating or sequential fashion to circumvent the difficulty in jointly minimizing w.r.t. the two primal blocks. Noting that (21) minimizes (U,V) simultaneously, (21)-(23) correspond to a two-block ADMM where convergence is guaranteed.

By ignoring the constant term independent of (U,V), the subproblem of (21) is equivalent to the following Frobenius norm minimization problem:

$\begin{matrix} {\min\limits_{U,V}{{({Uv})_{\Omega} - \left( {Z_{\Omega}^{k} - {\Lambda_{\Omega}^{k}/\rho} + M_{\Omega}} \right)}}_{F}^{2}} & (25) \end{matrix}$

which may be solved by the iterative

₂-regression, namely, process 1 as discussed earlier with p=2, with a complexity bound of

(

|Ω|r²). Here,

is the required iteration number for process 1 to converge at p=2.

On the other hand, the subproblem of (22) can be concisely expressed as

$\begin{matrix} {{\min\limits_{Z_{\Omega}}{\frac{1}{2}{{Z_{\Omega} - Y_{\Omega}^{k}}}_{F}^{2}}} + {\frac{1}{\rho}{Z_{\Omega}}_{p}^{p}}} & (26) \end{matrix}$

where

Y _(Ω) ^(k)=(U ^(k+1) V ^(k+1))_(Ω)+Λ_(Ω) ^(k) /ρ−M _(Ω).  (27)

Concerning the entries indexed by Ω because other entries of Z_(Ω) and Y_(Ω) ^(k) which are not in S are zero. z_(Ω), y_(Ω) ^(k), λ_(Ω) ^(k), and t_(Ω) ^(k)∈

^(|Ω|) are defined as the vectors that contain the entries in Ω of Z_(Ω), Y_(Ω) ^(k), Λ_(Ω) ^(k), and (U^(k)V^(k))_(Ω) respectively, in a column-by-column manner. Preferably, (26) is equivalent to the vector optimization problem:

$\begin{matrix} {{\min\limits_{Z_{\Omega}}{\frac{1}{2}{{z_{\Omega} - y_{\Omega}^{k}}}_{2}^{2}}} + {\frac{1}{\rho}{z_{\Omega}}_{p}^{p}}} & (28) \end{matrix}$

where the solution defines the proximity operator of the pth power of

-norm, which may be written as

z _(Ω) ^(k+1)=prox_(1/ρ)(y _(Ω) ^(k)).  (29)

After obtaining z_(Ω) ^(k+1), Z_(Ω) ^(k+1) may be determined. For notational simplicity, the subscripts and superscripts may be ignored as follows. z_(i) and y_(i) may be denoted as the ith entry of z and y for i=1, . . . , |Ω|, respectively. Because (28) is separable and hence it can be decomposed into |Ω| independent scalar problems:

$\begin{matrix} {{{\min\limits_{z_{i} \in {\mathbb{R}}}{g\left( z_{i} \right)}}:={{\frac{1}{2}\left( {z_{i} - y_{i}} \right)^{2}} + {\frac{1}{\rho}{z_{i}}^{p}}}},{i = 1},\ldots \mspace{14mu},{\Omega }} & (30) \end{matrix}$

The closed-form solution of (30) for p=1 is:

z _(i) *=sgn(y _(i))max(|y _(i)|−1/ρ,0)  (31)

which is known as the soft-thresholding operator and can be easily computed with a marginal complexity of

(|Ω|). The case of p∈(1,2) is not difficult to solve but requires an iterative procedure since it does not have a closed-form solution. Since the choice of p=1 is more robust than p∈(1,2) and computationally simpler, the latter is not considered. When the noise is very impulsive, the value of p<1 may be required. The solution for the scalar minimization problem of (30) with p<1 is:

$\begin{matrix} {z_{i}^{\bigstar} = \left\{ \begin{matrix} {0,} & {{{if}\mspace{14mu} {y_{i}}} \leq \tau} \\ {\arg \min\limits_{z_{i} \in {\{{0,t_{i}}\}}}} & {{{{if}\mspace{11mu} {y_{i}}} > \tau}\;} \end{matrix} \right.} & (32) \end{matrix}$

where

$\begin{matrix} {\tau = {\left( \frac{p\left( {1 - p} \right)}{\rho} \right)^{\frac{1}{2 - p}} + {\frac{p}{\rho}\left( \frac{p\left( {1 - p} \right)}{\rho} \right)^{\frac{p - 1}{2 - p}}}}} & (33) \end{matrix}$

is the threshold and t_(i)=sgn(y_(i))r_(i) with r_(i) being the unique root of the nonlinear equation:

$\begin{matrix} {{h(\theta)}:={{\theta + {\frac{p}{\rho}\theta^{p - 1}} - {y_{i}}} = 0}} & (34) \end{matrix}$

in the interval

$\left\lbrack {\left( {{p\left( {1 - p} \right)}/\rho} \right)^{\frac{1}{2 - p}},{y_{i}}} \right\rbrack$

where the bisection method can be applied.

Finally, an equivalent form of (23) is

λ_(Ω) ^(k+1)=λ_(Ω) ^(k)+ρ(t _(Ω) ^(k+1) −z _(Ω) ^(k+1) −m _(Ω))  (35)

The operations are in terms of vectors but not matrices, and its complexity is

(|Ω|). Also, at each iteration, (UV)_(Ω) instead of UV should be solved, whose complexity is

(|Ω|r) because only |Ω| inner products {u_(i) ^(T)v_(j)}_((i,j)∈Ω) are calculated.

The steps of ADMM for robust matrix completion are summarized as follows. The

₂-norm of the residual, that is, ∥t_(Ω) ^(k)−z_(Ω) ^(k)−m_(Ω)∥₂ can be used to check for convergence. Specifically, the process is terminated when

∥t _(Ω) ^(k) −z _(Ω) ^(k) −m _(Ω)∥₂<δ  (36)

where δ>0 is a small tolerance parameter.

Process 2: Input: M_(Ω), Ω, and rank r  Initialize: z⁰ = 0 and λ⁹ = 0  for k = 0, 1, . . . do   1) Solve LS matrix factorization     $\left( {U^{k + 1},V^{k + 1}} \right) = {\arg \mspace{14mu} {\min\limits_{U,V}{{({UV})_{\Omega} - \left( {Z_{\Omega}^{k} - {\Lambda_{\Omega}^{k}\text{/}p} + M_{\Omega}} \right)}}_{p}^{2}}}$    using Process 1 with p = 2.   2) Compute Y_(Ω) ^(k) = (U^(k+1)V^(k+1))_(Ω) + Λ_(Ω) ^(k)/p − M_(Ω) and form y_(Ω) ^(k) and    t_(Ω) ^(k+1) ← (U^(k+1)V^(k+1))_(Ω).   3) z_(Ω) ^(k+1) ← prox_(1/p)(y_(Ω) ^(k))   4) λ_(Ω) ^(k+1) ← λ_(Ω) ^(k) + p(t_(Ω) ^(k+1) − z_(Ω) ^(k+1) − m_(Ω))   Stop if a termination condition is satisfied.  end for Output: X = U^(k+1)V^(k+1)

These embodiments may be advantageous in that the process may be useful in a variety of applications such as collaborative filtering, image inpainting and restoration, system identification, node localization and genotype imputation.

Advantageously, various kind of signals may be approximated by a matrix whose rank r is much smaller than the row and column numbers, denoted by n₁ and n₂, respectively. Therefore, these signals may be processed by method involving matrix transformation. The invention may be applied to recover a low-rank matrix given only a subset of its entries, possibly with impulsive noise or outliers.

The process for robust matrix completion is based on low-rank matrix factorization and

-norm minimization of the residual with 0<p≤2. The incomplete data structure may be processed using low-rank matrix factorization with missing data by iteratively solving (n₁+n₂) linear

-regression problems, and alternating direction method of multipliers (ADMM) in the

-space may be used.

The two processes have comparable recovery performance and computational complexity of

(K|Ω|r²), where |Ω| is the number of observed entries and K is a fixed constant of several hundreds to thousands and dimension-independent. Therefore these embodiments of the present invention are advantageous in terms of computational simplicity, statistical accuracy and outlier-robustness.

The inventors also performed experiments to evaluate the system 200 in accordance with an embodiment of the present invention. In the experiment, experimental settings are provided with n₁=150, n₂=300, and the rank is r=10. The method in accordance with the embodiments of the present invention are compared with alternative methods, namely, SVT and SVP. A noise-free matrix M∈

of rank r is generated by the product of M₁∈

and M₂∈

whose entries satisfy the standard Gaussian distribution. 45% entries of M are randomly selected as the available observations. The normalized root mean square error (RMSE) is employed as the performance measure, which is defined as:

$\begin{matrix} {{{RMSE}\mspace{11mu} (X)} = \sqrt{E\left\{ \frac{{{X - M}}_{F}^{2}}{{M}_{F}^{2}} \right\}}} & (37) \end{matrix}$

where X is the result obtained by a matrix completion method, and is computed based on 100 independent trials.

With reference to FIG. 3, there is provided a result of the RMSE versus iteration number in the noise-free case where

-reg represents the iterative

-regression method in process 1. The result of the ADMM is not shown because for any p, process 2 converges to the true solution in one iteration. It is observed that the SVT, SVP and

-regression method converge to the true matrix with a linear rate. However, the latter converges much faster and only about ten iterations are needed to obtain an accurate solution. The CPU times based on a PC with a 3.2 GHz CPU and 4 GB memory for attaining RMSE≤10⁻⁵ of the SVT, SVP,

-regression with p=2 and p=1 and ADMM with p=1 are 10.7 s, 8.0 s, 0.28 s, 4.5 s, and 0.28 s, respectively.

The inventors also consider the noisy scenario where impulsive components are added to available entries in M. They are modeled by the two-term Gaussian mixture model (GMM) whose probability density function is given by

$\begin{matrix} {{p_{v}(v)} = {\sum\limits_{i = 1}^{2}\; {\frac{c_{i}}{\sqrt{2\pi}\sigma_{i}}{\exp \left( {- \frac{v^{2}}{2\sigma_{i}^{2}}} \right)}}}} & (38) \end{matrix}$

where 0≤c_(i)≤1 and σ_(i) ² are the probability and variance of the ith term, respectively, with c₁+c₂=1. If σ₂ ²>>σ₁ ² and c₂<c₁ are selected, large noise samples of variance σ₂ ² occurring with a smaller probability c₂ can be viewed as outliers embedded in Gaussian background noise of variance σ₁ ². Thus, the GMM can well model the phenomenon with both Gaussian noise and outliers. The total noise variance is σ_(v) ²=Σ_(i)c_(i)σ_(i) ² and the signal-to-noise ratio (SNR) is defined as

$\begin{matrix} {{SNR} = {\frac{{M_{\Omega}}_{F}^{2}}{{\Omega }\sigma_{v}^{2}}.}} & (39) \end{matrix}$

With reference to FIG. 4, there is provided a result of the RMSE versus iteration number in additive GMM noise at SNR=6 dB. The SVT and SVP cannot stably converge to a reasonable solution. Both

-regression and ADMM with p=1 converge fast, that is, in about ten iterations, to a solution with a higher accuracy while the

₂-regression cannot obtain an accurate estimation in impulsive noise. It is observed that a value of several tens for K_(reg) and K_(ADMM) is sufficient for convergence. Employing the stopping criteria of relative change of the current and previous iterations is less than 10⁻⁴ and (36) with δ=10⁻³ in the

-regression and ADMM methods, respectively, the CPU times of the SVT, SVP,

-regression with p=2 and p=1 and ADMM with p=1 are 197.3 s, 10.6 s, 0.25 s, 5.2 s and 3.1 s, respectively.

With reference to FIG. 5, there is provided a result of the RMSE versus SNR. Again, it is observed that the

-regression and ADMM with p=1 have the minimum RMSE for all SNRs and thus they perform better than the alternative methods. Therefore, the method is suitable for processing incomplete data structure which contains at least one noisy data element.

With reference to FIG. 6, matrix completion may also applied to image inpainting in salt-and-pepper noise. Preferably, the source image 206 may be converted to a grey-scale image, and the grey-scale image may then be represented by the matrix representation.

The missing data of the source image 206 correspond to “ICCV”, “2009”, and “LRTC” in the image. In addition, the available entries are contaminated by adding salt-and-pepper noise. For all methods, the rank is set to r=6.

The SVT method shows divergence and it is observed that SVP fails in recovering the image. In contrast, the

_(p)-regression and ADMM with p=1 are quite robust to the salt-and-pepper noise and they provide rather good estimates of the original image. It is also observed that the

₁-regression greatly improves the performance compared with the

₂-regression in impulsive noise environment. The CPU times of the SVP,

_(p)-regression with p=2 and p=1 and ADMM with p=1 are 20.3 s, 0.4 s, 7.8 s and 4.9 s, respectively.

These experimental results show that the embodiments of the present invention may converge faster than SVT and SVP since the computational complexity of the present invention is linear with the number of observed entries and hence it is scalable, even for the noise-free condition.

Although not required, the embodiments described with reference to the Figures can be implemented as an application programming interface (API) or as a series of libraries for use by a developer or can be included within another software application, such as a terminal or personal computer operating system or a portable computing device operating system. Generally, as program modules include routines, programs, objects, components and data files assisting in the performance of particular functions, the skilled person will understand that the functionality of the software application may be distributed across a number of routines, objects or components to achieve the same functionality desired herein.

It will also be appreciated that where the methods and systems of the present invention are either wholly implemented by computing system or partly implemented by computing systems thus any appropriate computing system architecture may be utilised. This will include standalone computers, network computers and dedicated hardware devices. Where the terms “computing system” and “computing device” are used, these terms are intended to cover any appropriate arrangement of computer hardware capable of implementing the function described.

It will be appreciated by persons skilled in the art that the term “database” may include any form of organized or unorganized data storage devices implemented in either software, hardware or a combination of both which are able to implement the function described.

It will be appreciated by persons skilled in the art that numerous variations and/or modifications may be made to the invention as shown in the specific embodiments without departing from the spirit or scope of the invention as broadly described. The present embodiments are, therefore, to be considered in all respects as illustrative and not restrictive.

Any reference to prior art contained herein is not to be taken as an admission that the information is common general knowledge, unless otherwise indicated. 

1. A method for processing a data structure, comprising the step of: providing an incomplete data structure arranged to represent source information; processing the incomplete data structure to determine at least one estimated data element of an output data structure; and transforming the source information to output information associated with the output data structure based on a combination of the incomplete data structure and the at least one estimated data element.
 2. The method for processing a data structure in accordance with claim 1, wherein the data structure is arranged to contain a plurality of data elements.
 3. The method for processing a data structure in accordance with claim 2, wherein the incomplete data structure contains at least one noisy data element.
 4. The method for processing a data structure in accordance with claim 2, wherein at least one of the plurality of data elements is missing in the incomplete data structure.
 5. The method for processing a data structure in accordance with claim 4, wherein the output data structure includes the at least one estimated data element filled in at least one corresponding missing entries in the incomplete data structure.
 6. The method for processing a data structure in accordance with claim 2, wherein the data structure includes a matrix filled with the plurality of data elements.
 7. The method for processing a data structure in accordance with claim 2, wherein the incomplete data structure is a low-rank matrix.
 8. The method for processing a data structure in accordance with claim 7, wherein the step of processing the incomplete data structure includes factorizing the low-rank matrix.
 9. The method for processing a data structure in accordance with claim 8, wherein the step of processing the incomplete data structure further comprises a step of

-norm minimization of residual with 0<p≤2.
 10. The method for processing a data structure in accordance with claim 9, wherein the step of processing the incomplete data structure further comprises a step of processing the factorized low-rank matrix by solving a (n₁+n₂) linear

-regression problem, wherein n₁ and n₂ denote a row number and a column number of the low-rank matrix.
 11. The method for processing a data structure in accordance with claim 10, wherein the process of solving a (n₁+n₂) linear

-regression problem involves an iterative process.
 12. The method for processing a data structure in accordance with claim 11, wherein the iterative process is an iteratively reweighted least squares process.
 13. The method for processing a data structure in accordance with claim 9, wherein the step of processing the incomplete data structure further comprising a step of applying an alternating direction method of multipliers in an

_(p)-space.
 14. The method for processing a data structure in accordance with claim 13, wherein the step of applying the alternating direction method of multipliers in an

_(p)-space includes solving a least squares matrix factorization problem in each of a plurality of iterations.
 15. The method for processing a data structure in accordance with claim 14, wherein the least squares matrix factorization problem is solved using a linear least squares regression process.
 16. The method for processing a data structure in accordance with claim 13, wherein the step of applying the alternating direction method of multipliers in an

_(p)-space includes obtaining a proximity operator of a p^(th) power of the

_(p)-norm.
 17. The method for processing a data structure in accordance with claim 16, wherein the proximity operator includes a closed-form solution for p=1.
 18. The method for processing a data structure in accordance with claim 16, wherein obtaining the proximity operator of a p^(th) power of the

-norm includes root finding of a scalar nonlinear equation for p<1.
 19. The method for processing a data structure in accordance with claim 1, wherein the source information is a source image including a missing portion.
 20. The method for processing a data structure in accordance with claim 19, wherein the output information is an inpainted image based on the source image.
 21. A method for image processing, comprising the steps of: transforming a source image to a matrix representation including a data structure; processing the data structure with the method in accordance with claim 1 so as to modify the matrix representation including the output data structure; and transforming the modified matrix representation to an output image.
 22. The method for image processing of claim 21, further comprising the step of converting the source image to a gray-scale image, wherein the gray-scale image is represented by the matrix representation.
 23. A system for use in processing a data structure, comprising: a transformation module arranged to generate an incomplete data structure representing source information; and a processing module arranged to process the incomplete data structure so as to determine at least one estimated data element of an output data structure; wherein the transformation module is further arranged to transform the source information to output information associated with the output data structure based on a combination of the incomplete data structure and the at least one estimated data element.
 24. The system in accordance with claim 23, wherein the data structure is arranged to contain a plurality of data elements.
 25. The system in accordance with claim 24, wherein the incomplete data structure contains at least one noisy data element.
 26. The system in accordance with claim 24, wherein at least one of the plurality of data elements is missing in the incomplete data structure.
 27. The system in accordance with claim 26, wherein the output data structure includes the at least one estimated data element filled in at least one corresponding missing entries in the incomplete data structure.
 28. The system in accordance with claim 24, wherein the data structure includes a matrix filled with the plurality of data elements.
 29. The system in accordance with claim 24, wherein the incomplete data structure is a low-rank matrix.
 30. The system in accordance with claim 23, wherein the source information is a source image including a missing portion.
 31. The system in accordance with claim 30, wherein the output information is an inpainted image based on the source image.
 32. The system in accordance with claim 23, wherein the transformation module is further arranged to convert the source image to a gray-scale image, wherein the gray-scale image is represented by the incomplete data structure. 